import type { MenuProps } from 'antd';
import { menuApi } from '@/services/cloud/api/menuApi';
import type { Menu } from '@/types/rbac';
import React from 'react';
import * as Icons from '@ant-design/icons';

// 统一导出图标解析函数，供服务与各页面复用
export const getAntdIcon = (iconName?: string): React.ReactNode => {
  if (!iconName) return undefined;
  const raw = String(iconName).trim();
  const endsWithKnownSuffix = /(Outlined|Filled|TwoTone)$/.test(raw);
  const pascalized = raw
    .replace(/[-_\s]+([a-zA-Z])/g, (_, c) => c.toUpperCase())
    .replace(/^[a-z]/, c => c.toUpperCase());
  const withSuffix = endsWithKnownSuffix ? pascalized : `${pascalized}Outlined`;

  const IconComp = (Icons as any)[raw] || (Icons as any)[pascalized] || (Icons as any)[withSuffix];
  return IconComp ? React.createElement(IconComp) : undefined;
};


/**
 * 菜单服务 - 基于V3-Cloud权限模型设计
 * 
 * 数据库模型：
 * - sys_menu: 菜单表，包含目录(1)、菜单(2)、按钮(3)三种类型
 * - sys_role_menu: 角色菜单关联表
 * - sys_user_role: 用户角色关联表
 * - sys_permission: 权限表，支持菜单权限、按钮权限、API权限
 */

// 用户类型枚举 - 对应不同的权限体系
export enum UserType {
  SYSTEM = 'system',    // 租户系统用户
  TENANT = 'tenant'     // 租户用户（暂未实现）
}

// 菜单服务响应接口
export interface MenuServiceResponse {
  success: boolean;
  data: Menu[];
  error?: string;
}

// 菜单服务类
class MenuService {

  /**
   * 统一的用户菜单获取接口
   * @param userType 用户类型
   * @param userId 用户ID（系统用户必需）
   * @param tenantCode 租户代码（租户用户必需）
   * @param isAdmin 是否为超级管理员
   */
  async getUserMenus(userType: UserType, userId?: string, tenantCode?: string, isAdmin?: boolean): Promise<MenuServiceResponse> {
    try {
      let menus: Menu[] = [];

      switch (userType) {
        case UserType.SYSTEM:
          if (!userId) {
            throw new Error('系统用户菜单获取需要用户ID');
          }
          menus = await this.fetchSystemUserMenus(userId, isAdmin);
          break;
        
        case UserType.TENANT:
          if (!tenantCode) {
            throw new Error('租户用户菜单获取需要租户代码');
          }
          menus = await this.fetchTenantUserMenus(tenantCode);
          break;
        
        default:
          throw new Error(`不支持的用户类型: ${userType}`);
      }

      // 构建菜单树结构
      const menuTree = this.buildMenuTree(menus);
      // 路径规范化，确保与路由匹配
      const normalizedTree = menuTree;

      return {
        success: true,
        data: normalizedTree
      };
    } catch (error) {
      console.error('菜单服务获取失败:', error);
      return {
        success: false,
        data: [],
        error: error instanceof Error ? error.message : '菜单获取失败'
      };
    }
  }

  // 路径规范化：去除 /system 前缀，将 /home 归一到 /dashboard，去掉末尾斜杠
  private normalizePath(path?: string): string | undefined {
    // 已根据用户要求移除前端路径规范化逻辑，直接使用后端返回的路径
    return path;
  }

  // 递归规范化菜单树中的 path
  private normalizeMenusPaths(menus: Menu[]): Menu[] {
    // 直接返回原始菜单树，不做路径变更
    return menus;
  }

  

  /**
   * 获取系统用户菜单（系统管理员）
   */
  private async fetchSystemUserMenus(userId: string, isAdmin?: boolean): Promise<Menu[]> {
      const res = await menuApi.getUserMenus(userId);
      return Array.isArray(res) ? this.getDefaultSystemMenus().concat(res) : this.getDefaultSystemMenus();
  }

  /**
   * 获取租户用户菜单（预留）
   */
  private async fetchTenantUserMenus(tenantCode: string): Promise<Menu[]> {
    try {
      // TODO: 租户菜单获取逻辑尚未提供API，暂时返回空数组
      return [];
    } catch (e) {
      console.error('获取租户用户菜单失败:', e);
      return [];
    }
  }

  /**
   * 默认系统菜单（接口异常时回退）
   */
  private getDefaultSystemMenus(): Menu[] {
    return [
      {
        id: 'home',
        code: 'HOME',
        name: '首页',
        path: '/home',
        icon: 'HomeOutlined',
        type: 2,
        status: 1,
        sort: 0,
        createTime: new Date().toISOString()
      },
    ];
  }

  /**
   * 构建菜单树结构（支持多级）
   */
  private buildMenuTree(menus: Menu[]): Menu[] {
    const menuMap = new Map<string, Menu>();
    const rootMenus: Menu[] = [];

    menus.forEach(menu => {
      const id = menu.id?.toString() || menu.code;
      if (!id) return;
      menuMap.set(id, { ...menu, children: [] });
    });

    menus.forEach(menu => {
      const id = menu.id?.toString() || menu.code;
      const parentId = menu.parentId?.toString();

      if (parentId && menuMap.has(parentId)) {
        const parent = menuMap.get(parentId)!;
        parent.children = parent.children || [];
        parent.children.push(menuMap.get(id)!);
      } else {
        rootMenus.push(menuMap.get(id)!);
      }
    });

    const sortMenus = (menuList: Menu[]) => {
      menuList.sort((a, b) => (a.sort || 0) - (b.sort || 0));
      menuList.forEach(menu => {
        if (menu.children && menu.children.length > 0) {
          sortMenus(menu.children);
        }
      });
    };

    sortMenus(rootMenus);
    return rootMenus;
  }

  /**
   * 将菜单图标字符串解析为 Ant Design 图标组件
   */
  private resolveIcon(iconName?: string): React.ReactNode {
    return getAntdIcon(iconName);
  }

  /**
   * 将菜单数据转换为Ant Design Menu组件所需的格式
   */
  convertToAntdMenuItems(menus: Menu[]): MenuProps['items'] {
    if (!menus || !Array.isArray(menus)) {
      return [];
    }

    const convertMenu = (menu: Menu): any => {
      // 只转换菜单类型（type=2）和目录类型（type=1）
      if (menu.type === 3 || menu.type === 'button') {
        return null; // 跳过按钮类型
      }

      const resolvedIcon = this.resolveIcon(menu.icon);
      const fallbackIconName = (menu.type === 1) ? 'FolderOutlined' : 'AppstoreOutlined';

      const item: any = {
        key: menu.code || menu.id,
        label: menu.name,
        icon: resolvedIcon ?? getAntdIcon(fallbackIconName),
      };

      // 如果是菜单类型且有路径，设置路径（规范化）
      if (menu.type === 2 || menu.type === 'menu') {
        const path = menu.path || undefined;
        if (path) {
          item.path = path;
          // 为叶子菜单项添加onClick处理，确保可以点击导航
          item.onClick = () => {
            // 这里会被DynamicMenu组件的handleAntdMenuClick覆盖
          };
        }
      }

      // 处理子菜单
      if (menu.children && menu.children.length > 0) {
        const childItems = menu.children
          .map(convertMenu)
          .filter(item => item !== null);
        
        if (childItems.length > 0) {
          item.children = childItems;
        }
      }

      return item;
    };

    return menus.map(convertMenu).filter(item => item !== null);
  }
}

// 导出菜单服务实例
export const menuService = new MenuService();
export default menuService;